package handler

import (
	"Data-API-MCP/backend/internal/domain/entity"
	"Data-API-MCP/backend/internal/domain/service"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// MCPServiceHandler MCP服务处理器
type MCPServiceHandler struct {
	mcpService *service.MCPService
	logger     *zap.Logger
}

// NewMCPServiceHandler 创建MCP服务处理器
func NewMCPServiceHandler(
	mcpService *service.MCPService,
	logger *zap.Logger,
) *MCPServiceHandler {
	return &MCPServiceHandler{
		mcpService: mcpService,
		logger:     logger,
	}
}

// CreateService 创建MCP服务
// @Summary 创建MCP服务
// @Description 创建一个新的MCP服务
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param service body entity.MCPService true "MCP服务信息"
// @Success 201 {object} entity.MCPService "创建成功"
// @Failure 400 {object} ErrorResponse "请求错误"
// @Failure 401 {object} ErrorResponse "未授权"
// @Failure 500 {object} ErrorResponse "服务器错误"
// @Router /api/v1/services [post]
func (h *MCPServiceHandler) CreateService(c *gin.Context) {
	var service entity.MCPService
	if err := c.ShouldBindJSON(&service); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求参数"})
		return
	}

	if err := h.mcpService.CreateService(c.Request.Context(), &service); err != nil {
		h.logger.Error("创建MCP服务失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建服务失败"})
		return
	}

	c.JSON(http.StatusCreated, service)
}

// GetServices 获取MCP服务列表
// @Summary 获取MCP服务列表
// @Description 获取所有MCP服务列表
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Success 200 {array} entity.MCPService "服务列表"
// @Failure 401 {object} ErrorResponse "未授权"
// @Failure 500 {object} ErrorResponse "服务器错误"
// @Router /api/v1/services [get]
func (h *MCPServiceHandler) GetServices(c *gin.Context) {
	services, err := h.mcpService.GetServices(c.Request.Context())
	if err != nil {
		h.logger.Error("获取MCP服务列表失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取服务列表失败"})
		return
	}

	c.JSON(http.StatusOK, services)
}

// GetService 获取单个MCP服务
// @Summary 获取单个MCP服务
// @Description 获取指定ID的MCP服务
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} entity.MCPService "服务信息"
// @Failure 401 {object} ErrorResponse "未授权"
// @Failure 404 {object} ErrorResponse "服务不存在"
// @Failure 500 {object} ErrorResponse "服务器错误"
// @Router /api/v1/services/{id} [get]
func (h *MCPServiceHandler) GetService(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	service, err := h.mcpService.GetService(c.Request.Context(), id)
	if err != nil {
		h.logger.Error("获取MCP服务失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取服务失败"})
		return
	}

	c.JSON(http.StatusOK, service)
}

// UpdateService 更新MCP服务
// @Summary 更新MCP服务
// @Description 更新指定ID的MCP服务
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Param service body entity.MCPService true "MCP服务信息"
// @Success 200 {object} entity.MCPService "更新成功"
// @Failure 400 {object} ErrorResponse "请求错误"
// @Failure 401 {object} ErrorResponse "未授权"
// @Failure 404 {object} ErrorResponse "服务不存在"
// @Failure 500 {object} ErrorResponse "服务器错误"
// @Router /api/v1/services/{id} [put]
func (h *MCPServiceHandler) UpdateService(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	var service entity.MCPService
	if err := c.ShouldBindJSON(&service); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求参数"})
		return
	}

	service.ID = id
	if err := h.mcpService.UpdateService(c.Request.Context(), &service); err != nil {
		h.logger.Error("更新MCP服务失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "更新服务失败"})
		return
	}

	c.JSON(http.StatusOK, service)
}

// DeleteService 删除MCP服务
// @Summary 删除MCP服务
// @Description 删除指定ID的MCP服务
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} object "成功"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id} [delete]
func (h *MCPServiceHandler) DeleteService(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	if err := h.mcpService.DeleteService(c.Request.Context(), id); err != nil {
		h.logger.Error("删除MCP服务失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "删除服务失败"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "服务删除成功"})
}

// GetServiceStatus 获取服务状态
// @Summary 获取服务状态
// @Description 获取指定ID的MCP服务状态
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} object "服务状态"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id}/status [get]
func (h *MCPServiceHandler) GetServiceStatus(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	status, err := h.mcpService.GetServiceStatus(c.Request.Context(), id)
	if err != nil {
		h.logger.Error("获取服务状态失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取服务状态失败"})
		return
	}

	c.JSON(http.StatusOK, status)
}

// GetServiceMetrics 获取服务指标
// @Summary 获取服务指标
// @Description 获取指定ID的MCP服务指标
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} object "服务指标"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id}/metrics [get]
func (h *MCPServiceHandler) GetServiceMetrics(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	metrics, err := h.mcpService.GetServiceMetrics(c.Request.Context(), id)
	if err != nil {
		h.logger.Error("获取服务指标失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取服务指标失败"})
		return
	}

	c.JSON(http.StatusOK, metrics)
}

// GetServiceLogs 获取服务日志
// @Summary 获取服务日志
// @Description 获取指定ID的MCP服务日志
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} object "服务日志"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id}/logs [get]
func (h *MCPServiceHandler) GetServiceLogs(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	logs, err := h.mcpService.GetServiceLogs(c.Request.Context(), id)
	if err != nil {
		h.logger.Error("获取服务日志失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取服务日志失败"})
		return
	}

	c.JSON(http.StatusOK, logs)
}

// GetServiceConfig 获取服务配置
// @Summary 获取服务配置
// @Description 获取指定ID的MCP服务配置
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} object "服务配置"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id}/config [get]
func (h *MCPServiceHandler) GetServiceConfig(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	config, err := h.mcpService.GetServiceConfig(c.Request.Context(), id)
	if err != nil {
		h.logger.Error("获取服务配置失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "获取服务配置失败"})
		return
	}

	c.JSON(http.StatusOK, config)
}

// UpdateServiceConfig 更新服务配置
// @Summary 更新服务配置
// @Description 更新指定ID的MCP服务配置
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Param config body map[string]interface{} true "服务配置"
// @Success 200 {object} object "成功"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id}/config [put]
func (h *MCPServiceHandler) UpdateServiceConfig(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	var config map[string]interface{}
	if err := c.ShouldBindJSON(&config); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的配置参数"})
		return
	}

	if err := h.mcpService.UpdateServiceConfig(c.Request.Context(), id, config); err != nil {
		h.logger.Error("更新服务配置失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "更新服务配置失败"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "配置更新成功"})
}

// ReloadService 重载服务配置
// @Summary 重载服务配置
// @Description 重载指定ID的MCP服务配置
// @Tags MCP服务管理
// @Accept json
// @Produce json
// @Param id path string true "服务ID"
// @Success 200 {object} object "成功"
// @Failure 400 {object} object "请求错误"
// @Failure 401 {object} object "未授权"
// @Failure 404 {object} object "服务不存在"
// @Failure 500 {object} object "服务器错误"
// @Router /api/v1/services/{id}/reload [post]
func (h *MCPServiceHandler) ReloadService(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的服务ID"})
		return
	}

	if err := h.mcpService.ReloadService(c.Request.Context(), id); err != nil {
		h.logger.Error("重载服务配置失败", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{"error": "重载服务配置失败"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "服务重载成功"})
}
